json-parse-even-better-errors

What is json-parse-even-better-errors?

The json-parse-even-better-errors package is an npm package that provides an improved JSON.parse function. It offers better error messages than the default JSON.parse, making it easier to debug issues with JSON data. It can pinpoint the exact location and cause of the error in the JSON string.

What are json-parse-even-better-errors's main functionalities?

Improved error messages

This feature enhances the error messages provided by JSON.parse. In the code sample, if the JSON is invalid, it will throw an error with a message that includes the position and reason for the failure, making it easier to identify and fix the issue.

const parseJSON = require('json-parse-even-better-errors');
try {
  const obj = parseJSON('{"foo": "bar", "baz": }');
} catch (e) {
  console.error(e.message);
}

Other packages similar to json-parse-even-better-errors

fast-json-parse

This package offers a safe way to parse JSON strings without try-catch blocks. It returns an object with an error and value property. It is similar to json-parse-even-better-errors in providing a safer JSON parsing experience but does not focus on detailed error messages.

secure-json-parse

Secure-json-parse provides safe parsing of JSON strings, protecting against prototype pollution attacks. It is similar to json-parse-even-better-errors in that it enhances the JSON parsing process, but it focuses on security rather than error message clarity.

parse-json

Parse-json is another JSON parsing library that provides more informative error messages with a clear indication of where the parsing failed. It is similar to json-parse-even-better-errors in its goal to provide better error messages, but it may differ in implementation and the exact output of the errors.

README

json-parse-even-better-errors

json-parse-even-better-errors is a Node.js library for getting nicer errors out of JSON.parse(), including context and position of the parse errors.

It also preserves the newline and indentation styles of the JSON data, by putting them in the object or array in the Symbol.for('indent') and Symbol.for('newline') properties.

Install

$ npm install --save json-parse-even-better-errors

Table of Contents

• Example
• Features
• Contributing
• API
  • parse

Example

const parseJson = require('json-parse-even-better-errors')

parseJson('"foo"') // returns the string 'foo'
parseJson('garbage') // more useful error message
parseJson.noExceptions('garbage') // returns undefined

Features

• Like JSON.parse, but the errors are better.
• Strips a leading byte-order-mark that you sometimes get reading files.
• Has a noExceptions method that returns undefined rather than throwing.
• Attaches the newline character(s) used to the Symbol.for('newline') property on objects and arrays.
• Attaches the indentation character(s) used to the Symbol.for('indent') property on objects and arrays.

Indentation

To preserve indentation when the file is saved back to disk, use data[Symbol.for('indent')] as the third argument to JSON.stringify, and if you want to preserve windows \r\n newlines, replace the \n chars in the string with data[Symbol.for('newline')].

For example:

const txt = await readFile('./package.json', 'utf8')
const data = parseJsonEvenBetterErrors(txt)
const indent = Symbol.for('indent')
const newline = Symbol.for('newline')
// .. do some stuff to the data ..
const string = JSON.stringify(data, null, data[indent]) + '\n'
const eolFixed = data[newline] === '\n' ? string
  : string.replace(/\n/g, data[newline])
await writeFile('./package.json', eolFixed)

Indentation is determined by looking at the whitespace between the initial { and [ and the character that follows it. If you have lots of weird inconsistent indentation, then it won't track that or give you any way to preserve it. Whether this is a bug or a feature is debatable ;)

API

parse(txt, reviver = null, context = 20)

Works just like JSON.parse, but will include a bit more information when an error happens, and attaches a Symbol.for('indent') and Symbol.for('newline') on objects and arrays. This throws a JSONParseError.

parse.noExceptions(txt, reviver = null)

Works just like JSON.parse, but will return undefined rather than throwing an error.

class JSONParseError(er, text, context = 20, caller = null)

Extends the JavaScript SyntaxError class to parse the message and provide better metadata.

Pass in the error thrown by the built-in JSON.parse, and the text being parsed, and it'll parse out the bits needed to be helpful.

context defaults to 20.

Set a caller function to trim internal implementation details out of the stack trace. When calling parseJson, this is set to the parseJson function. If not set, then the constructor defaults to itself, so the stack trace will point to the spot where you call new JSONParseError.

Changelog

3.0.2 (2024-05-04)

Bug Fixes

• c45eec2 #54 node 22 behavior (@lukekarrys)

Chores

• fecc81f #54 bump @npmcli/template-oss to 4.22.0 (@lukekarrys)
• 3c7bd80 #54 postinstall for dependabot template-oss PR (@lukekarrys)
• 04a6747 #53 bump @npmcli/template-oss from 4.21.3 to 4.21.4 (@dependabot[bot])